// 引入配置
import config from '@/util/index.js'
import * as Api from '@/api/page'

// 后端api地址
const apiUrl = config.get('apiUrl')
var util = {};
  util.formdata =function(obj = {}) {
    let result = ''
    for (let name of Object.keys(obj)) {
      let value = obj[name];
      result += 
      '\r\n--XXX' +
      '\r\nContent-Disposition: form-data; name=\"'+ name +'\"'+ 
      '\r\n' +
      '\r\n' + value
    }
    return result + '\r\n--XXX--'
  }
// 页面数据
 util.postData = function (req, data) {
    return new Promise(function (resolve, reject) {
		let token = uni.getStorageSync('admin_token');
      uni.request({
        url: apiUrl+req,
        method: 'post',
        header: {
          'content-type':'multipart/form-data; boundary=XXX',
		  'Authorization':'Bearer ' + token
        },
        data: util.formdata(data),
        success: function (res) {
          resolve(res.data)
        },
        fail: function () {
          wx.hideLoading();
          wx.showModal({
            title: '网络错误',
            content: '网络出错，请刷新重试',
            showCancel: false
          })
          return typeof cb == "function" && cb(false)
        }
      });
    });
  }
  // 页面数据
   util.getData = function (req, data) {
      return new Promise(function (resolve, reject) {
  		let token = uni.getStorageSync('admin_token');
        uni.request({
          url: apiUrl+req,
          method: 'get',
			 header: {
			   'content-type':'application/json',
				'Authorization':'Bearer ' + token
			 },
          data: data,
          success: function (res) {
            resolve(res.data)
          },
          fail: function () {
            wx.hideLoading();
            wx.showModal({
              title: '网络错误',
              content: '网络出错，请刷新重试',
              showCancel: false
            })
            return typeof cb == "function" && cb(false)
          }
        });
      });
    }
	
	// 页面数据
	 util.removeData = function (req) {
	    return new Promise(function (resolve, reject) {
			let token = uni.getStorageSync('admin_token');
	      uni.request({
	        url: apiUrl+req,
	        method: 'delete',
			 header: {
			   'content-type':'application/json',
				'Authorization':'Bearer ' + token
			 },
	        success: function (res) {
	          resolve(res)
	        },
	        fail: function () {
	          wx.hideLoading();
	          wx.showModal({
	            title: '网络错误',
	            content: '网络出错，请刷新重试',
	            showCancel: false
	          })
	          return typeof cb == "function" && cb(false)
	        }
	      });
	    });
	  }
	// 页面数据
	 util.getDataOne = function (req) {
	    return new Promise(function (resolve, reject) {
			let token = uni.getStorageSync('admin_token');
	      uni.request({
	        url: apiUrl+req,
	        method: 'get',
			 header: {
			   'content-type':'application/json',
				'Authorization':'Bearer ' + token
			 },
	        success: function (res) {
	          resolve(res.data)
	        },
	        fail: function () {
	          wx.hideLoading();
	          wx.showModal({
	            title: '网络错误',
	            content: '网络出错，请刷新重试',
	            showCancel: false
	          })
	          return typeof cb == "function" && cb(false)
	        }
	      });
	    });
	  }
	  // 页面数据
	   util.editData = function (req, data) {
	      return new Promise(function (resolve, reject) {
	  		  let token = uni.getStorageSync('admin_token');
	        uni.request({
	          url: apiUrl+req,
	          method: 'put',
	          header: {
	            'content-type':'application/json',
	  			'Authorization':'Bearer ' + token
	          },
	          data:data,
	          success: function (res) {
	            resolve(res.data)
	          },
	          fail: function () {
	            wx.hideLoading();
	            wx.showModal({
	              title: '网络错误',
	              content: '网络出错，请刷新重试',
	              showCancel: false
	            })
	            return typeof cb == "function" && cb(false)
	          }
	        });
	      });
	    }
  // 页面数据
   util.reqData = function (req, data) {
      return new Promise(function (resolve, reject) {
		  let token = uni.getStorageSync('admin_token');
        uni.request({
          url: apiUrl+req,
          method: 'post',
          header: {
            'content-type':'application/json',
			'Authorization':'Bearer ' + token
          },
          data:data,
          success: function (res) {
            resolve(res.data)
          },
          fail: function () {
            wx.hideLoading();
            wx.showModal({
              title: '网络错误',
              content: '网络出错，请刷新重试',
              showCancel: false
            })
            return typeof cb == "function" && cb(false)
          }
        });
      });
    }
  // 可以new多个request来支持多个域名请求
  const $http = new request({
    // 接口请求地址
    baseUrl: apiUrl,
    // 服务器本地上传文件地址
    fileUrl: apiUrl,
    // 服务器上传图片默认url
    defaultUploadUrl: 'upload/image',
    // 设置请求头（如果使用报错跨域问题，可能是content-type请求类型和后台那边设置的不一致）
    header: {
      'content-type': 'application/json;charset=utf-8'
    },
    // 请求超时时间, 单位ms（默认15秒）
    timeout: 15000,
    // 默认配置（可不写）
    config: {
      // 是否自动提示错误
      isPrompt: true,
      // 是否显示加载动画
      load: true,
      // 是否使用数据工厂
      isFactory: true
    }
  })
  // 当前接口请求数
  let requestNum = 0
  // 请求开始拦截器
  $http.requestStart = options => {
    if (options.load) {
      if (requestNum <= 0) {
		  const whiteList = [
		  	"login"
		  ]
		  const token = uni.getStorageSync('admin_token');
		//判断该请求是否需要拦截
		const notNeed = whiteList.includes(method);
		//不在白名单且没有token则拦截
		if (!notNeed && !token) {
			uni.reLaunch({
				url: "../../pages/student/login/index"
			});
			  //这里是我封装的一个toast,根据自己情况return
			return {
				Status: 1,
				Message: "请重新登录",
				Data: null
			};
		}
        // 打开加载动画
        uni.showLoading({
          title: '加载中',
          mask: true
        })
      }
      requestNum += 1
    }
    // 图片上传大小限制
    if (options.method == "FILE" && options.maxSize) {
      // 文件最大字节: options.maxSize 可以在调用方法的时候加入参数
      const maxSize = options.maxSize
      for (let item of options.files) {
        if (item.size > maxSize) {
          setTimeout(() => {
            uni.showToast({
              title: "图片过大，请重新上传",
              icon: "none"
            })
          }, 10)
          return false
        }
      }
    }
    // 请求前加入当前终端
    // options.header['platform'] = store.getters.platform
    // 请求前加入Token
    // options.header['Access-Token'] = store.getters.token
    // return false 表示请求拦截，不会继续请求
    return options
  }

// 请求结束
$http.requestEnd = options => {
  // 判断当前接口是否需要加载动画
  if (options.load) {
    requestNum = requestNum - 1
    if (requestNum <= 0) {
      uni.hideLoading()
    }
  }
}
// 错误回调
$http.requestError = e => {
  if (e.statusCode === 0) {
    throw e
  } else {
    setTimeout(() => {
      uni.showToast({
        title: `网络请求出错：${e.errMsg}`,
        icon: "none",
        duration: 2500
      })
    })
  }
}

// export default {$http,util}
/**
 * header参数设置
 * @param {Object} header
 */
function headers(header) {
	let headers = {};
	let Token = uni.getStorageSync("admin_token")
	if (Token.length!==0) { //有token的情况下设置token
		let token = {
		'Authorization':'Bearer ' + Token,
		'content-type':'application/json'};
		headers = Object.assign(token,header);
	}else {
		headers = header;
	}
	return headers;
}
 
 
/**
 * 请求封装
 * @param {Object} url
 * @param {Object} method
 * @param {Object} data
 * @param {Object} headers
 * @param {Object} resType
 */
 function request(url,method,data,header,resType) {
	 return new Promise((resolve,reject)=>{
		 uni.request({
		 	url: apiUrl + url,
		 	method: method || 'GET',
		 	data: data || {},
		 	header: header	|| {},
		 	success: (res)=>{
		 		if(res.data.code===401) {  //请求接口返回401(token异常)后直接返回401
		 			resolve(401)
		 		}else {
		 			resolve(res); //没有401时返回响应数据
		 		}
		 	},
		 	fail: (err)=>{
		 		reject(err);
		 	}
		 })
	 })
 }
 
/**
 * export请求；请求重试机制
 * @param {Object} url
 * @param {Object} method
 * @param {Object} data
 * @param {Object} headers
 * @param {Object} resType
 */
export default (url,method,data,header,resType)=>{
	return new Promise((resolve,reject)=>{
		request(url,method,data,headers(header),resType).then(res=>{
			if(res===401) { 	//接口请求401,401是request请求手动抛出的401
				let userIfo = uni.getStorage('userifo');
				console.log("userIfos",userIfo)
				var params = {
				    username: userIfo.username,
				    password: userIfo.password 
				}
				// Api.loginAcmont(params).then(res=> {
				//     if (res.code == 200) {
				//         //本地存储能力 120107199001244532  13087946216 
				//         uni.setStorageSync('admin_token', res.data.token);
				// 	    Api.getUserInfo().then(response => {
				// 			if(response.code==200){
				// 				uni.setStorage({
				// 					key: 'userifo',
				// 					data: JSON.stringify(response.data)
				// 				})
				// 				request(url,method,data,headers(header),resType).then(res=>{
				// 					resolve(res)
				// 				})
				// 			}
				// 	    })
				//     } 
				// })
			}else {		//没有token异常时直接返回响应数据
				resolve(res)
			}
		}).catch(err=>{reject(err)})
	})
}
